// import got from 'got';
// // import * as request from 'request';
// import * as FormData from 'form-data';
// import { Logger } from '@nestjs/common';
// import { CommonConfig } from '../config';
// const apiUrl = CommonConfig.ENV.get('SHORT_URL_API');

/**
 * @Description 工具类
 */
export class CommonUtil {
  /**
   * 获取新增的对象元素
   * @param oriData
   * @param newData
   */
  static findObjectNewKey(oriData: any, newData: any) {
    return Object.keys(newData).filter((key) => !oriData.hasOwnProperty(key));
  }

  /**
   * 获取两个对象中变化的key-value
   * @param oriData
   * @param newData
   */
  static objectChangedValues(oriData: any, newData: any) {
    const changes: any = {};
    for (const key in oriData) {
      if (oriData.hasOwnProperty(key) && newData.hasOwnProperty(key)) {
        if (oriData[key] !== newData[key]) {
          changes[key] = newData[key]; // 保存变化的值
        }
      }
    }
    return changes;
  }

  static listToTree(list, id, parentId, childKey, concatId = false) {
    const map = {},
      tree = [];
    let node, i;
    for (i = 0; i < list.length; i++) {
      map[list[i][id]] = i; // 初始化映射
      if (concatId) {
        list[i][`${childKey}${list[i][id]}`] = [];
      } else {
        list[i][childKey] = []; // 初始化children数组
      }
    }
    for (i = 0; i < list.length; i++) {
      node = list[i];
      if (node[parentId] !== 0) {
        // 根节点的parentId为"0"
        // 找到父节点，并将当前节点添加到父节点的children数组中
        if (concatId) {
          // console.log(node, list[map[node[parentId]]], node[parentId], map[node[parentId]], `${childKey}${node[parentId]}`)
          list[map[node[parentId]]][`${childKey}${node[parentId]}`].push(node);
        } else {
          list[map[node[parentId]]][childKey].push(node); // 初始化children数组
        }
      } else {
        tree.push(node); // 添加到树的顶层
      }
    }
    return tree;
  }

  static list2Tree(list, id, parentId, childKey = 'children') {
    const resArr = [];
    for (const v of list) {
      // 找这个元素的 父亲(item.id === v.parentId)
      // 去arr中 中 找v的父亲，找到的话，把v添加到父亲的children属性中
      const parentNode = list.find((item) => item[id] == v[parentId]);
      if (parentNode) {
        // 如果没有找到父亲-说明 他是一级目录
        if (parentNode[childKey]) {
          parentNode[childKey].push(v);
        } else {
          parentNode[childKey] = [v];
        }
      } else {
        //说明这个v 没有父亲
        resArr.push(v);
      }
    }
    return resArr;
  }

  static treeToList(tree) {
    // 定义空数组 -方法所有的tree中的元素
    const resArr = [];
    // 定义了数组，放了tree里面的 第一层元素
    const queue = [...tree];
    // 循环--条件  queue 数组的长度不为0 就一直循环
    while (queue.length) {
      // 每次删除queue中第一个元素
      const v = queue.shift();
      // 如果可以取出来就把他添加到resArr
      if (v) resArr.push(v);
      // 判断v是否有孩子
      if (v && v.children) {
        queue.push(...v.children);
      }
    }
    return resArr;
  }

  static treeToOption(tree, id, val, childKey = 'children') {
    // 定义空数组 -方法所有的tree中的元素
    const resArr = [];
    // 定义了数组，放了tree里面的 第一层元素
    const queue = [...tree];
    // 循环--条件  queue 数组的长度不为0 就一直循环
    while (queue.length) {
      // 每次删除queue中第一个元素
      const v = queue.shift();
      const option: any = {};
      // 如果可以取出来就把他添加到resArr
      if (v) {
        option[id] = v[id];
        option[val] = v[val];
        resArr.push(option);
      }
      // 判断v是否有孩子
      if (v && v[childKey]) {
        const childOptions = v[childKey].map((item) => {
          const childOption: any = {};
          childOption[id] = item[id];
          childOption[val] = `|--${item[val]}`;
          return childOption;
        });
        resArr.push(...childOptions);
      }
    }
    return resArr;
  }

  /**
   * 获取随机数字字符串
   * @param num
   */
  static randomDigitNumber(num) {
    const characters = '0123456789';
    let code = '';
    for (let i = 0; i < num; i++) {
      const randomIndex = Math.floor(Math.random() * characters.length);
      code += characters[randomIndex];
    }
    return code;
  }

  static isStrictJSON(obj) {
    if (typeof obj === 'string') {
      try {
        const parsed = JSON.parse(obj);
        return typeof parsed === 'object' || Array.isArray(parsed);
      } catch {
        return false;
      }
    } else {
      return typeof obj === 'object' && obj !== null;
    }
  }
}
